Hauptseite Zu yanwittmann.de

Zur Hauptseite

<     7. Zusammengesetzte Datentypen     >

Software >> Java & OOP


Bisher hatten wir nur einfache, primitive Datentypen und Felder. Doch auf lange Sicht werden diese irgendwann unhandlich. Man schaue sich dieses Beispiel an:

char punkt1_Name = 'p';     
int punkt1_X = 12;
int punkt1_Y = 34;
char punkt2_Name = 'q';
int punkt2_X = 67;
int punkt2_Y = 24;
char punkt3_Name = 'r';
int punkt3_X = 164;
int punkt3_Y = 96;
Java

Hier wird versucht, drei Punkte mit je zwei Koordinatenwerten (x, y) und einem Namen abzuspeichern. Das braucht aber alleine dafür schon je drei Variablen pro Punkt und man kann nicht einfach so einen neuen hinzufügen, ohne viele weitere Variablen anzulegen. Das geht auch einfacher.

Zusammengefasste Datentypen sind genau das, was der Name vermuten lässt: Mehrere Werte in einem Typ zusammengefasst. Dieser Typ ist, nicht wie ein int oder char, kein primitiver Typ mehr, daher gilt für diesen dann bei Java call by reference. Im Beispiel von oben hätten wir dann also einen Typ Punkt der drei Werte enthält: int x, int y und char name.


Erstellen eines zusammengesetzten Datentyps in Java

In Java nennen sich solche zusammengesetzten Typen Klassen. Du hast diese sogar schon verwendet: jedes mal, wenn du Code geschrieben hast, hast du unbewusst eine solche Klasse erstellt und diese mit Code und Variablen befüllt. Eine Klasse wird durch das Codeword class angedeutet. Eine Klasse entspricht (meistens zumindest) einer .java-Datei. Also, wenn wir unsere Klasse Punkt schreiben wollen, müssten wir in einer Datei Punkt.java folgenden Code haben:

public class Punkt {     
    private int x, y;     
    private char name;     

    public Punkt(int x, int y, char name) {     
        this.x = x;
        this.y = y;
        this.name = name;
    }
}
Java


Es beginnt mit public class Punkt: Die Sichtbarkeit public bedeutet einfach, dass man diese Klasse von überall aus verwendet werden kann. class ist wie gesagt einfach nur das Schlüsselwort, dass nun eine Klasse definiert wird und Punkt ist der Name der Klasse.
Nun kommen alle Variablen, die man in dem zusammengesetzen Datentyp speichern möchte, also unsere Koordinaten x und y und der Name name. Es handelt sich hierbei um globale Variablen, welche immer auf private gesetzt sein sollten. Generell sollte man so oft wie nur möglich private als Sichtbarkeit verwenden.
Danach kommt etwas, das aussieht wie ein Unterprogramm nur ohne Rückgabewert. Es handelt sich hierbei um den Konstruktor der Klasse, also das, was aufgerufen wird, wenn wir ein neues Objekt von diesem Typen erzeugen. Wir wollen diesem unsere Koordinaten und den Namen als Parameter mitgeben: int x, int y, char name
Doch diese nur als Parameter mitzugeben bringt noch nicht viel, jetzt müssen wir noch die globalen Variablen auf die entsprechenden Werte setzen: this bedeutet, dass wir auf ein Klassenattribut zugreifen möchten, also im Beispiel oben zuerst auf die globale Variable x: this.x. Damit greifen wir nicht auf den Parameter, sondern auf die globale Variable zu. Nun wollen wir es auf den parameter x setzen, also this.x = x. Das gleiche passiert mit den anderen beiden Parametern.

Nun wollen wir aber auch noch auf die Werte zugreifen können, was wir ja im Moment nicht können, da sie auf private gesetzt sind. Dazu brauchen wir nur getter und setter, also Funktionen die uns den Wert geben/setzen, zu der Punkt-Klasse hinzufügen:

public int getX() {     
    return x;
}

public int getY() {
    return y;
}

public char getName() {     
    return name;
}

public void setX(int x) {     
    this.x = x;
}

public void setY(int y) {
    this.y = y;
}
Java



Nun das Beispiel von oben mit unserem neuen zusammengesetzten Datentyp:

Punkt p = new Punkt(12, 34, 'p');     
Punkt q = new Punkt(67, 24, 'q');
Punkt r = new Punkt(164, 96, 'r');     
Java

Anstatt neun Zeilen nur drei, das ist doch nicht schlecht! Wenn wir nun auf die Werte zugreifen wollen, können wir einfach die getter und setter verwenden:

p.setX( q.getY() );     
System.out.println(p.getName() + ": x=" + p.getX() + " y=" + p.getY());     
//...
Java


Allgemeine Vorgehensweise

Um einen zusammengesetzten Typen zu erstellen muss man folgende Schritte befolgen:

  1. Einen passenden Namen für den Typ finden
  2. Benötigte Werte und deren Typen herausfinden (also bei unserem Punkt oben x, y und name)
  3. Eine Klasse mit dem Namen und den Variablen anlegen
  4. Einen Konstruktor erstellen, in dem die Werte initialisiert werden
  5. Benötigte getter und setter für die Variablen erstellen

Aufgaben

    Frage 1
Wofür sind zusammengesetzte Typen gut?

    Frage 2
Was wird in dem Beispiel mit dem Punkt p und q oben ausgegeben?

    Frage 3
Könnte man bei dem obigen Beispiel den Name des Punktes nach der ersten initialisierung noch setzen? Warum?

    Frage 4
Erstelle einen zusammengesetzen Typ in Java Linie mit sinnvollen Variablen, gettern, settern und einer berechneLaenge-Funktion!

    Frage 5
Verwende die in Aufgabe 4 angegebene Java-Klasse um ein Objekt davon zu erzeugen und von diesem die Länge auszugeben!